home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 18 / CU Amiga Magazine's Super CD-ROM 18 (1997)(EMAP Images)(GB)[!][issue 1998-01].iso / CUCD / Programming / AmigaE / Src / OOmodules / commodity.e < prev    next >
Text File  |  1996-07-20  |  11KB  |  467 lines
  1. OPT MODULE
  2. OPT OSVERSION=37
  3.  
  4. MODULE  'oomodules/library/commodities',
  5.         'oomodules/object',
  6.  
  7.         'commodities',
  8.         'libraries/commodities',
  9.         'exec/ports'
  10.  
  11.  
  12. DEF nb:PTR TO newbroker,
  13.     hotkey, hotkeyID,
  14.  
  15.     cxlib:PTR TO commodities
  16.  
  17. EXPORT OBJECT commodity OF object
  18. /****** object/commodity ******************************
  19.  
  20.     NAME
  21.         commodity of object -- Commodity object. Installs a commodity in the
  22.             system.
  23.  
  24.     PURPOSE
  25.         Add commodity facilities to your application.
  26.  
  27.     ATTRIBUTES
  28.         broker:LONG -- Pointer to broker structure as returned and used
  29.             by the commodities.library
  30.  
  31.         messagePort:PTR TO mp -- Message port of the commodity. Messages
  32.             arrive here when we press the hotkey, enable the commodity and
  33.             so on.
  34.  
  35.         openGUIProc:LONG -- Address of the proc to call when the commodity is
  36.             told to open the gui (via hotkey or exchange program). No
  37.             arguments.
  38.  
  39.         closeGUIProc:LONG -- The opposite of the open gui proc.
  40.  
  41.         killProc:LONG -- Address of proc to call when the commodity is told
  42.             to quit. If left NIL a standard proc is called that removes the
  43.             commodity from the system, frees the message port and other
  44.             allocated resources. That standard proc is removeFromSystem().
  45.             You may put your own proc here and call removeFromSystem() when
  46.             you're finished. See autodoc of that proc.
  47.  
  48.     NOTES
  49.         A quick & dirty implementation from one of my old sources. I'm sure it
  50.         isn't finished.
  51.  
  52.     SEE ALSO
  53.         object
  54.  
  55. ********/
  56.   broker
  57.   messagePort:PTR TO mp
  58.   openGUIProc
  59.   closeGUIProc
  60.   killProc
  61. ENDOBJECT
  62.  
  63. PROC init() OF commodity
  64. /****** commodity/init ******************************
  65.  
  66.     NAME
  67.         init() of commodity -- Initialization of the object.
  68.  
  69.     SYNOPSIS
  70.         commodity.init()
  71.  
  72.     FUNCTION
  73.         Opens commodities library if needed and creates message port. Some
  74.         flags are set. The commodity is set to be unique.
  75.  
  76.     SEE ALSO
  77.         commodity
  78.  
  79. ********/
  80.  
  81.   NEW cxlib.new()
  82.  
  83.   self.messagePort := CreateMsgPort()
  84.   NEW nb
  85.  
  86.   nb.unique := NBU_UNIQUE OR NBU_NOTIFY
  87.   nb.flags := COF_SHOW_HIDE
  88.   nb.port := self.messagePort
  89.  
  90.   hotkeyID := 1
  91.  
  92.   SUPER self.init()
  93.  
  94. ENDPROC
  95.  
  96. PROC select(opts,i) OF commodity
  97. /****** commodity/select ******************************
  98.  
  99.     NAME
  100.         select() of commodity -- Selection of action.
  101.  
  102.     SYNOPSIS
  103.         commodity.select(LONG, LONG)
  104.  
  105.         commodity.select(opts, i)
  106.  
  107.     FUNCTION
  108.         The following tags are recognized:
  109.             "name" -- Name of cx.
  110.  
  111.             "title" -- Title of cx. Some simple line that says who did it.
  112.  
  113.             "desc" -- Short description line ('OS3 version', 'Testversion')
  114.  
  115.             "vers" -- Version byte
  116.  
  117.             "hotk" -- Hotkey string, e.g. 'control alt d'
  118.  
  119.             "open" -- Pointer to proc that will be called if the cx is told
  120.                 to open the gui. No arguments are passed.
  121.  
  122.             "clos" -- Pointer to proc that will be called if the cx is told
  123.                 to close the gui. No arguments are passed.
  124.  
  125.             "kill" -- Pointer to proc that will be called if the cx is told
  126.                 to kill the gui. No arguments are passed. If you use this tag
  127.                 be sure to call removeFromSystem().
  128.  
  129.             "now" -- If this tag is found in the list the cx is added to the
  130.                 system at once. Do *NOT* provide any more tags, this one has
  131.                 to be the last one in the list. If you do, behaviour is
  132.                 undefined.
  133.  
  134.         The tags "name", "titl", "desc" and "hotkey" have to be provided.
  135.         However, this is not checked. If you forget one, behaviour is
  136.         undefined.
  137.  
  138.     INPUTS
  139.         opts:LONG -- Option list.
  140.  
  141.         i:LONG -- Index of optionlist.
  142.  
  143.     RESULT
  144.         LONG -- Current index we are at.
  145.  
  146.     EXAMPLE
  147.          NEW cx.new(["name", 'DevEnv',
  148.                      "titl", 'DevEnv 0.5ß © 1995,6 Gregor Goldbach',
  149.                      "desc", 'E Development Environment',
  150.                      "vers", 5,
  151.                      "hotk", 'control alt d',
  152.                      "open", {showMainWindow},
  153.                      "now"])
  154.     SEE ALSO
  155.         commodity
  156.  
  157. ********/
  158. DEF item
  159.  
  160.   item:=ListItem(opts,i)
  161.  
  162.  
  163.   SELECT item
  164.  
  165.     CASE "name"
  166.  
  167.       INC i
  168.       nb.name := ListItem(opts,i)
  169.  
  170.     CASE "titl"
  171.  
  172.       INC i
  173.       nb.title := ListItem(opts,i)
  174.  
  175.     CASE "desc"
  176.  
  177.       INC i
  178.       nb.descr := ListItem(opts,i)
  179.  
  180.     CASE "hotk"
  181.  
  182.       INC i
  183.       hotkey := ListItem(opts,i)
  184.  
  185.     CASE "vers"
  186.  
  187.       INC i
  188.       nb.version := ListItem(opts,i)
  189.  
  190.     CASE "now"
  191.  
  192.       self.addToSystem()
  193.       END nb
  194.  
  195.     CASE "open"
  196.  
  197.       INC i
  198.       self.openGUIProc := ListItem(opts,i)
  199.  
  200.     CASE "clos"
  201.  
  202.       INC i
  203.       self.closeGUIProc := ListItem(opts,i)
  204.  
  205.     CASE "kill"
  206.  
  207.       INC i
  208.       self.killProc := ListItem(opts,i)
  209.  
  210.   ENDSELECT
  211.  
  212. ENDPROC i
  213.  
  214. EXPORT PROC addToSystem() OF commodity
  215. /****** commodity/addToSystem ******************************
  216.  
  217.     NAME
  218.         addToSystem() of commodity -- Adds commodity to the system.
  219.  
  220.     SYNOPSIS
  221.         commodity.addToSystem()
  222.  
  223.     FUNCTION
  224.         The commodity is installed by the commodities library, arguments set
  225.         in select() will be used. Check self.broker to know if the creation
  226.         was successful or not. There may be an exception for this in the
  227.         future.
  228.  
  229.     SEE ALSO
  230.         commodity
  231.  
  232. ********/
  233. DEF filter, sender, translate
  234.  
  235.   IF nb
  236.  
  237.     self.broker:=CxBroker(nb,0) -> Create broker with the filled nb structure
  238.  
  239.     IF self.broker
  240.  
  241.  
  242.         /* Create a filter which checks *
  243.          * input events for our hotkey. */
  244.         IF filter:=CreateCxObj(CX_FILTER,hotkey,0)
  245.            /* We have to attach the filter to *
  246.             * our broker.                     */
  247.           AttachCxObj(self.broker,filter)
  248.            /* Create a sender which sends us *
  249.             * hotkey/data info to our port   */
  250.           IF sender:=CreateCxObj(CX_SEND,self.messagePort,hotkeyID)
  251.             /* Attach the sender to the filter */
  252.             AttachCxObj(filter,sender)
  253.             /* Create a translator which 'eats' *
  254.              * the input event if it was ours.  */
  255.             IF translate:=CreateCxObj(CX_TRANSLATE,0,0)
  256.               /* Attach also the translator to the filter */
  257.               AttachCxObj(filter,translate)
  258.               /* Global error-check on our filter */
  259.               IF (CxObjError(filter)=0)
  260.                 /* No errors. Let's go! */
  261.                 ActivateCxObj(self.broker,TRUE)
  262.                 /* We use a subroutine now         *
  263.                  * (only to have a cleaner source) */
  264.               ENDIF
  265.             ENDIF
  266.           ENDIF
  267.         ENDIF
  268.       ENDIF
  269.     ENDIF
  270.  
  271. ENDPROC
  272.  
  273. PROC removeFromSystem() OF commodity
  274. /****** commodity/removeFromSystem ******************************
  275.  
  276.     NAME
  277.         removeFromSystem() of commodity --
  278.  
  279.     SYNOPSIS
  280.         commodity.removeFromSystem()
  281.  
  282.     FUNCTION
  283.  
  284.     RESULT
  285.  
  286.     EXAMPLE
  287.  
  288.     CREATION
  289.  
  290.     HISTORY
  291.  
  292.     NOTES
  293.  
  294.     SEE ALSO
  295.         commodity
  296.  
  297. ********/
  298.  
  299.   DeleteCxObjAll(self.broker)
  300.   DeleteMsgPort(self.messagePort)
  301.  
  302.   END cxlib
  303.  
  304. ENDPROC
  305.  
  306. EXPORT PROC handleInputs() OF commodity
  307. /****** commodity/handleInputs ******************************
  308.  
  309.     NAME
  310.         handleInputs() of commodity --
  311.  
  312.     SYNOPSIS
  313.         commodity.handleInputs()
  314.  
  315.     FUNCTION
  316.         Handles general inputs for the commodity. These are the things
  317.         you can do with Exchange or any clone of that program. When you
  318.         tell the cx to pop up (via hotkey or the Exchange button) the
  319.         proc you provided at init() is called.
  320.  
  321.         When the cx is told to commit suicide the 'close GUI' proc is called
  322.         (if provided) and then the cx is removed from the system. Note that
  323.         this is the case only if you didn't provide your own kill proc.
  324.  
  325.     RESULT
  326.  
  327.     EXAMPLE
  328.  
  329.     CREATION
  330.  
  331.     HISTORY
  332.  
  333.     NOTES
  334.  
  335.     SEE ALSO
  336.         commodity
  337.  
  338. ********/
  339. DEF msg,msgid,msgtype,rcode,
  340.     proc
  341.  
  342.   REPEAT
  343.     rcode:=0        /* reset main LOOP RETURN code */
  344.  
  345.     /* Wait for any message at our port */
  346.  
  347.     WaitPort(self.messagePort)
  348.  
  349.  
  350.     /* Get the message :) */
  351.  
  352.     IF msg:=GetMsg(self.messagePort)
  353.  
  354.       /* Get more data from message for CX */
  355.  
  356.       msgid:=CxMsgID(msg)
  357.       msgtype:=CxMsgType(msg)
  358.  
  359.       /* Reply (here OR later but important!) */
  360.  
  361.       ReplyMsg(msg)
  362.  
  363.       /* Check for CXM_IEVENT (Hotkey) */
  364.  
  365.       IF msgtype=CXM_IEVENT
  366.  
  367.         /* Was it our hotkey? */
  368.  
  369.         IF msgid=hotkeyID
  370.  
  371.           /*** Here the hotkey action takes place! ***/
  372.  
  373.           proc := self.openGUIProc
  374.           IF proc THEN proc()
  375.  
  376.         ENDIF
  377.  
  378.       /* Check for CXM_COMMAND (Exchange, ...) */
  379.  
  380.       ELSEIF msgtype=CXM_COMMAND
  381.  
  382.         /* Exchange command Disable */
  383.  
  384.         IF msgid=CXCMD_DISABLE
  385.  
  386.           /*** Remove patches / stop cx-action here ***/
  387.  
  388.           ActivateCxObj(self.broker,FALSE)
  389.  
  390.           /* Exchange command Enable */
  391.  
  392.         ELSEIF msgid=CXCMD_ENABLE
  393.  
  394.           /*** Install patches / start our cx-action here ***/
  395.  
  396.           ActivateCxObj(self.broker,TRUE)
  397.  
  398.           /* Exchange command Show (if COF_SHOW_HIDE flag is SET) */
  399.  
  400.         ELSEIF msgid=CXCMD_APPEAR
  401.  
  402.           /*** Open our GUI/window here ***/
  403.  
  404.           proc := self.openGUIProc
  405.           IF proc THEN proc()
  406.  
  407.           /* Exchange command Hide (see CMD_APPEAR) */
  408.  
  409.         ELSEIF msgid=CXCMD_DISAPPEAR
  410.  
  411.           /*** Close our GUI/window here ***/
  412.  
  413.  
  414.           /* We were started again by a stupid user, *
  415.            * so we tell him and ask to quit.         *
  416.            * (CXCMD_UNIQUE if nb.unique filled)      *
  417.            * rcode becomes 1 if user wants to quit   */
  418.  
  419.           proc := self.closeGUIProc
  420.           IF proc THEN proc()
  421.  
  422.         ELSEIF msgid=CXCMD_UNIQUE
  423.  
  424.           rcode:=EasyRequestArgs(0,[20,0,'CX 37.0','CX already works.\nQuit it now?','Quit|Cancel'],0,0)
  425.  
  426.           /* Exchange Killer command */
  427.  
  428.         ELSEIF msgid=CXCMD_KILL
  429.  
  430.           proc := self.killProc
  431.           IF proc
  432.  
  433.             proc()
  434.  
  435.           ELSE
  436.  
  437.             proc := self.closeGUIProc
  438.             IF proc THEN proc()
  439.  
  440.  
  441.           ENDIF
  442.  
  443.           rcode:=1
  444.  
  445.           /* COMMAND check end */
  446.  
  447.         ENDIF
  448.  
  449.       /* COMMAND & IEVENT check end */
  450.  
  451.       ENDIF
  452.  
  453.     /* message scanned & replied */
  454.  
  455.     ENDIF
  456.  
  457.   /* get the next message from our master */
  458.  
  459.   UNTIL rcode
  460.  
  461. ENDPROC
  462.  
  463. /*EE folds
  464. -1
  465. 17 44 19 30 22 115 25 56 
  466. EE folds*/
  467.